home *** CD-ROM | disk | FTP | other *** search
/ Champak 49 / Volume 49 - JOGO DISK .iso / Games / gasmania.swf / scripts / DefineSprite_313 / frame_15 / DoAction.as
Text File  |  2007-10-01  |  57KB  |  1,134 lines

  1. var ┬º\x01┬º = 972;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 972)
  6.    {
  7.       set("\x01",eval("\x01") - 674);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 396)
  12.    {
  13.       set("\x01",eval("\x01") + 423);
  14.       if(┬º┬ºpop())
  15.       {
  16.          set("\x01",eval("\x01") - 537);
  17.       }
  18.       continue;
  19.    }
  20.    if(eval("\x01") == 909)
  21.    {
  22.       set("\x01",eval("\x01") - 249);
  23.       ┬º┬ºpush(true);
  24.       continue;
  25.    }
  26.    if(eval("\x01") == 705)
  27.    {
  28.       set("\x01",eval("\x01") + 23);
  29.       continue;
  30.    }
  31.    if(eval("\x01") == 819)
  32.    {
  33.       set("\x01",eval("\x01") - 537);
  34.       ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  35.       trace(┬º┬ºpop());
  36.       while(true)
  37.       {
  38.          if(eval(┬º┬ºpop()) == 845)
  39.          {
  40.             set("\x01",eval("\x01") - 559);
  41.          }
  42.          else if(eval("\x01") == 957)
  43.          {
  44.             set("\x01",eval("\x01") - 533);
  45.          }
  46.          else
  47.          {
  48.             if(eval("\x01") == 956)
  49.             {
  50.                set("\x01",eval("\x01") - 551);
  51.                loop8:
  52.                while(true)
  53.                {
  54.                   if(┬º┬ºpop() == ┬º┬ºpop())
  55.                   {
  56.                      set("\x01",eval("\x01") + 308);
  57.                      addr776:
  58.                      ┬º┬ºpush(true);
  59.                      while(true)
  60.                      {
  61.                         if(eval("\x01") == 735)
  62.                         {
  63.                            set("\x01",eval("\x01") - 590);
  64.                            ┬º┬ºpush(true);
  65.                            continue;
  66.                         }
  67.                         if(eval("\x01") == 887)
  68.                         {
  69.                            set("\x01",eval("\x01") + 87);
  70.                            gotoAndStop(56608);
  71.                            break loop0;
  72.                         }
  73.                         if(eval("\x01") == 494)
  74.                         {
  75.                            set("\x01",eval("\x01") - 319);
  76.                            ┬º┬ºpush(true);
  77.                            continue;
  78.                         }
  79.                         if(eval("\x01") == 902)
  80.                         {
  81.                            set("\x01",eval("\x01") - 637);
  82.                            continue;
  83.                         }
  84.                         if(eval("\x01") == 670)
  85.                         {
  86.                            set("\x01",eval("\x01") + 232);
  87.                            ┬º┬ºpush({});
  88.                            break loop0;
  89.                         }
  90.                         if(eval("\x01") == 974)
  91.                         {
  92.                            set("\x01",eval("\x01") - 80);
  93.                            continue;
  94.                         }
  95.                         if(eval("\x01") == 500)
  96.                         {
  97.                            set("\x01",eval("\x01") - 230);
  98.                            ┬º┬ºpush(true);
  99.                            continue;
  100.                         }
  101.                         if(eval("\x01") == 755)
  102.                         {
  103.                            set("\x01",eval("\x01") - 641);
  104.                            continue;
  105.                         }
  106.                         if(eval("\x01") == 83)
  107.                         {
  108.                            set("\x01",eval("\x01") + 685);
  109.                            continue;
  110.                         }
  111.                         ┬º┬ºpush(eval("\x01"));
  112.                         ┬º┬ºpush(476);
  113.                         continue loop8;
  114.                      }
  115.                      addr776:
  116.                   }
  117.                   else if(eval("\x01") == 739)
  118.                   {
  119.                      set("\x01",eval("\x01") - 551);
  120.                      if(┬º┬ºpop())
  121.                      {
  122.                         set("\x01",eval("\x01") - 133);
  123.                      }
  124.                      ┬º┬ºgoto(addr776);
  125.                   }
  126.                   else if(eval("\x01") == 145)
  127.                   {
  128.                      set("\x01",eval("\x01") + 742);
  129.                      if(┬º┬ºpop())
  130.                      {
  131.                         set("\x01",eval("\x01") + 87);
  132.                      }
  133.                      ┬º┬ºgoto(addr776);
  134.                   }
  135.                   else if(eval("\x01") == 7)
  136.                   {
  137.                      set("\x01",eval("\x01") + 469);
  138.                      ┬º┬ºgoto(addr776);
  139.                   }
  140.                   else if(eval("\x01") == 132)
  141.                   {
  142.                      set("\x01",eval("\x01") + 762);
  143.                      ┬º┬ºgoto(addr776);
  144.                   }
  145.                   else if(eval("\x01") == 894)
  146.                   {
  147.                      set("\x01",eval("\x01") - 155);
  148.                      ┬º┬ºgoto(addr776);
  149.                      ┬º┬ºpush(true);
  150.                   }
  151.                   else
  152.                   {
  153.                      if(eval("\x01") == 10)
  154.                      {
  155.                         set("\x01",eval("\x01") + 449);
  156.                         if(┬º┬ºpop())
  157.                         {
  158.                            set("\x01",eval("\x01") - 376);
  159.                         }
  160.                      }
  161.                      else
  162.                      {
  163.                         if(eval("\x01") == 853)
  164.                         {
  165.                            set("\x01",eval("\x01") + 123);
  166.                            break loop0;
  167.                         }
  168.                         if(eval("\x01") == 318)
  169.                         {
  170.                            set("\x01",eval("\x01") + 182);
  171.                         }
  172.                         else
  173.                         {
  174.                            if(eval("\x01") != 629)
  175.                            {
  176.                               if(eval("\x01") == 359)
  177.                               {
  178.                                  set("\x01",eval("\x01") + 396);
  179.                                  break loop0;
  180.                               }
  181.                               if(eval("\x01") == 920)
  182.                               {
  183.                                  addr1087:
  184.                                  ┬º┬ºpush("\x01");
  185.                                  ┬º┬ºpush("\x01");
  186.                                  while(true)
  187.                                  {
  188.                                     set(┬º┬ºpop(),eval(┬º┬ºpop()) - 426);
  189.                                     ┬º┬ºgoto(addr776);
  190.                                     ┬º┬ºgoto(addr1087);
  191.                                  }
  192.                                  addr1089:
  193.                               }
  194.                               else if(eval("\x01") == 805 ? (set("\x01",eval("\x01") + 81), new ┬º\┬º\┬ºpop()┬º()) : eval("\x01") == 175)
  195.                               {
  196.                                  set("\x01",eval("\x01") + 519);
  197.                                  if(┬º┬ºpop())
  198.                                  {
  199.                                     set("\x01",eval("\x01") - 224);
  200.                                  }
  201.                                  ┬º┬ºgoto(addr776);
  202.                               }
  203.                               else
  204.                               {
  205.                                  if(eval("\x01") == 188)
  206.                                  {
  207.                                     set("\x01",eval("\x01") - 133);
  208.                                     break loop0;
  209.                                  }
  210.                                  if(eval("\x01") == 855)
  211.                                  {
  212.                                     set("\x01",eval("\x01") - 361);
  213.                                     ┬º┬ºgoto(addr776);
  214.                                  }
  215.                                  else if(eval("\x01") == 768)
  216.                                  {
  217.                                     set("\x01",eval("\x01") - 767);
  218.                                     ┬º┬ºgoto(addr776);
  219.                                     ┬º┬ºpush(true);
  220.                                  }
  221.                                  else if(eval("\x01") != 941)
  222.                                  {
  223.                                     if(eval("\x01") == 1)
  224.                                     {
  225.                                        set("\x01",eval("\x01") + 669);
  226.                                        if(┬º┬ºpop())
  227.                                        {
  228.                                           set("\x01",eval("\x01") + 232);
  229.                                        }
  230.                                     }
  231.                                     else if(eval("\x01") == 588)
  232.                                     {
  233.                                        set("\x01",eval("\x01") - 323);
  234.                                     }
  235.                                     else
  236.                                     {
  237.                                        if(eval("\x01") != 32)
  238.                                        {
  239.                                           if(eval("\x01") == 161)
  240.                                           {
  241.                                              set("\x01",eval("\x01") + 694);
  242.                                              while(true)
  243.                                              {
  244.                                                 if(!┬º┬ºpop())
  245.                                                 {
  246.                                                    set("\x01",eval("\x01") - 777);
  247.                                                    if(┬º┬ºpop())
  248.                                                    {
  249.                                                       set("\x01",eval("\x01") + 38);
  250.                                                    }
  251.                                                 }
  252.                                                 else if(eval("\x01") == 863)
  253.                                                 {
  254.                                                    set("\x01",eval("\x01") - 414);
  255.                                                    ┬º┬ºpush(true);
  256.                                                 }
  257.                                                 else if(eval("\x01") == 132)
  258.                                                 {
  259.                                                    set("\x01",eval("\x01") + 655);
  260.                                                    ┬º┬ºpush(true);
  261.                                                 }
  262.                                                 else
  263.                                                 {
  264.                                                    if(eval("\x01") == 210)
  265.                                                    {
  266.                                                       set("\x01",eval("\x01") + 187);
  267.                                                       break loop0;
  268.                                                    }
  269.                                                    if(eval("\x01") == 789)
  270.                                                    {
  271.                                                       set("\x01",eval("\x01") - 566);
  272.                                                    }
  273.                                                    else
  274.                                                    {
  275.                                                       if(eval("\x01") == 753)
  276.                                                       {
  277.                                                          set("\x01",eval("\x01") - 491);
  278.                                                          break loop0;
  279.                                                       }
  280.                                                       if(eval("\x01") == 397)
  281.                                                       {
  282.                                                          set("\x01",eval("\x01") - 142);
  283.                                                       }
  284.                                                       else if(eval("\x01") == 805)
  285.                                                       {
  286.                                                          set("\x01",eval("\x01") + 58);
  287.                                                       }
  288.                                                       else if(eval("\x01") == 465)
  289.                                                       {
  290.                                                          set("\x01",eval("\x01") - 333);
  291.                                                       }
  292.                                                       else if(eval("\x01") == 382)
  293.                                                       {
  294.                                                          set("\x01",eval("\x01") + 536);
  295.                                                       }
  296.                                                       else if(eval("\x01") == 420)
  297.                                                       {
  298.                                                          set("\x01",eval("\x01") + 39);
  299.                                                       }
  300.                                                       else if(eval("\x01") == 157)
  301.                                                       {
  302.                                                          set("\x01",eval("\x01") - 48);
  303.                                                       }
  304.                                                       else if(eval("\x01") == 262)
  305.                                                       {
  306.                                                          set("\x01",eval("\x01") + 487);
  307.                                                       }
  308.                                                       else if(eval("\x01") == 449)
  309.                                                       {
  310.                                                          set("\x01",eval("\x01") + 160);
  311.                                                          if(┬º┬ºpop())
  312.                                                          {
  313.                                                             set("\x01",eval("\x01") - 84);
  314.                                                          }
  315.                                                       }
  316.                                                       else
  317.                                                       {
  318.                                                          if(eval("\x01") == 937)
  319.                                                          {
  320.                                                             set("\x01",eval("\x01") - 132);
  321.                                                             break loop0;
  322.                                                          }
  323.                                                          if(eval("\x01") == 242)
  324.                                                          {
  325.                                                             set("\x01",eval("\x01") - 110);
  326.                                                          }
  327.                                                          else if(eval("\x01") == 874)
  328.                                                          {
  329.                                                             set("\x01",eval("\x01") + 103);
  330.                                                             if(┬º┬ºpop())
  331.                                                             {
  332.                                                                set("\x01",eval("\x01") - 735);
  333.                                                             }
  334.                                                          }
  335.                                                          else
  336.                                                          {
  337.                                                             if(eval("\x01") == 713)
  338.                                                             {
  339.                                                                set("\x01",eval("\x01") - 635);
  340.                                                                break loop0;
  341.                                                             }
  342.                                                             if(eval("\x01") == 627)
  343.                                                             {
  344.                                                                set("\x01",eval("\x01") - 417);
  345.                                                                if(┬º┬ºpop())
  346.                                                                {
  347.                                                                   set("\x01",eval("\x01") + 187);
  348.                                                                }
  349.                                                             }
  350.                                                             else if(eval("\x01") == 199)
  351.                                                             {
  352.                                                                set("\x01",eval("\x01") + 532);
  353.                                                             }
  354.                                                             else if(eval("\x01") == 731)
  355.                                                             {
  356.                                                                set("\x01",eval("\x01") + 143);
  357.                                                                ┬º┬ºpush(true);
  358.                                                             }
  359.                                                             else
  360.                                                             {
  361.                                                                if(eval("\x01") == 977)
  362.                                                                {
  363.                                                                   set("\x01",eval("\x01") - 735);
  364.                                                                   break loop0;
  365.                                                                }
  366.                                                                if(eval("\x01") == 787)
  367.                                                                {
  368.                                                                   set("\x01",eval("\x01") - 74);
  369.                                                                   if(┬º┬ºpop())
  370.                                                                   {
  371.                                                                      set("\x01",eval("\x01") - 635);
  372.                                                                   }
  373.                                                                }
  374.                                                                else
  375.                                                                {
  376.                                                                   if(eval("\x01") != 78)
  377.                                                                   {
  378.                                                                      if(eval("\x01") == 109)
  379.                                                                      {
  380.                                                                         set("\x01",eval("\x01") + 157);
  381.                                                                         stop();
  382.                                                                         gotoAndPlay(2);
  383.                                                                         delete this.onEnterFrame;
  384.                                                                         break loop0;
  385.                                                                      }
  386.                                                                      if(eval("\x01") == 266)
  387.                                                                      {
  388.                                                                         set("\x01",eval("\x01") - 266);
  389.                                                                         break loop0;
  390.                                                                      }
  391.                                                                      break loop0;
  392.                                                                   }
  393.                                                                   set("\x01",eval("\x01") + 31);
  394.                                                                }
  395.                                                             }
  396.                                                          }
  397.                                                       }
  398.                                                    }
  399.                                                 }
  400.                                                 loop4:
  401.                                                 while(true)
  402.                                                 {
  403.                                                    if(eval("\x01") == 584)
  404.                                                    {
  405.                                                       set("\x01",eval("\x01") + 324);
  406.                                                       ┬º┬ºpush(true);
  407.                                                       continue;
  408.                                                    }
  409.                                                    if(eval("\x01") == 881)
  410.                                                    {
  411.                                                       set("\x01",eval("\x01") - 346);
  412.                                                       stop();
  413.                                                       break loop0;
  414.                                                    }
  415.                                                    if(eval("\x01") == 918)
  416.                                                    {
  417.                                                       set("\x01",eval("\x01") + 20);
  418.                                                       ┬º┬ºpush(true);
  419.                                                       continue;
  420.                                                    }
  421.                                                    if(eval("\x01") == 712)
  422.                                                    {
  423.                                                       set("\x01",eval("\x01") + 41);
  424.                                                       if(┬º┬ºpop())
  425.                                                       {
  426.                                                          set("\x01",eval("\x01") - 491);
  427.                                                       }
  428.                                                       continue;
  429.                                                    }
  430.                                                    if(eval("\x01") == 518)
  431.                                                    {
  432.                                                       set("\x01",eval("\x01") + 345);
  433.                                                       continue;
  434.                                                    }
  435.                                                    if(eval("\x01") == 459)
  436.                                                    {
  437.                                                       set("\x01",eval("\x01") + 168);
  438.                                                       ┬º┬ºpush(true);
  439.                                                       continue;
  440.                                                    }
  441.                                                    if(eval("\x01") == 161)
  442.                                                    {
  443.                                                       set("\x01",eval("\x01") + 38);
  444.                                                       break loop0;
  445.                                                    }
  446.                                                    if(eval("\x01") == 842)
  447.                                                    {
  448.                                                       set("\x01",eval("\x01") - 111);
  449.                                                       continue;
  450.                                                    }
  451.                                                    if(eval("\x01") == 88)
  452.                                                    {
  453.                                                       set("\x01",eval("\x01") + 661);
  454.                                                       continue;
  455.                                                    }
  456.                                                    if(eval("\x01") == 572)
  457.                                                    {
  458.                                                       set("\x01",eval("\x01") + 309);
  459.                                                       if(┬º┬ºpop())
  460.                                                       {
  461.                                                          set("\x01",eval("\x01") - 346);
  462.                                                       }
  463.                                                       continue;
  464.                                                    }
  465.                                                    if(eval("\x01") == 749)
  466.                                                    {
  467.                                                       set("\x01",eval("\x01") - 177);
  468.                                                       ┬º┬ºpush(true);
  469.                                                       continue;
  470.                                                    }
  471.                                                    if(eval("\x01") == 525)
  472.                                                    {
  473.                                                       set("\x01",eval("\x01") - 302);
  474.                                                       continue;
  475.                                                    }
  476.                                                    if(eval("\x01") == 255)
  477.                                                    {
  478.                                                       set("\x01",eval("\x01") + 296);
  479.                                                       ┬º┬ºpush(true);
  480.                                                       continue;
  481.                                                    }
  482.                                                    if(eval("\x01") == 535)
  483.                                                    {
  484.                                                       set("\x01",eval("\x01") - 76);
  485.                                                       continue;
  486.                                                    }
  487.                                                    if(eval("\x01") == 687)
  488.                                                    {
  489.                                                       set("\x01",eval("\x01") - 432);
  490.                                                       continue;
  491.                                                    }
  492.                                                    if(eval("\x01") == 908)
  493.                                                    {
  494.                                                       set("\x01",eval("\x01") + 29);
  495.                                                       if(┬º┬ºpop())
  496.                                                       {
  497.                                                          set("\x01",eval("\x01") - 132);
  498.                                                       }
  499.                                                       continue;
  500.                                                    }
  501.                                                    if(eval("\x01") == 609)
  502.                                                    {
  503.                                                       ┬º┬ºpush("\x01");
  504.                                                    }
  505.                                                    else
  506.                                                    {
  507.                                                       while(true)
  508.                                                       {
  509.                                                          if(eval("\x01") == 551)
  510.                                                          {
  511.                                                             set("\x01",eval("\x01") + 373);
  512.                                                             if(┬º┬ºpop())
  513.                                                             {
  514.                                                                set("\x01",eval("\x01") - 365);
  515.                                                             }
  516.                                                          }
  517.                                                          else
  518.                                                          {
  519.                                                             if(eval("\x01") == 924)
  520.                                                             {
  521.                                                                set("\x01",eval("\x01") - 365);
  522.                                                                break loop0;
  523.                                                             }
  524.                                                             if(eval("\x01") == 559)
  525.                                                             {
  526.                                                                set("\x01",eval("\x01") + 359);
  527.                                                             }
  528.                                                             else
  529.                                                             {
  530.                                                                if(eval("\x01") != 223)
  531.                                                                {
  532.                                                                   break loop4;
  533.                                                                }
  534.                                                                set("\x01",eval("\x01") + 489);
  535.                                                                ┬º┬ºpush(true);
  536.                                                             }
  537.                                                          }
  538.                                                          continue loop4;
  539.                                                       }
  540.                                                       addr304:
  541.                                                    }
  542.                                                 }
  543.                                              }
  544.                                           }
  545.                                           else
  546.                                           {
  547.                                              if(eval("\x01") == 270)
  548.                                              {
  549.                                                 set("\x01",eval("\x01") - 109);
  550.                                                 if(┬º┬ºpop())
  551.                                                 {
  552.                                                    set("\x01",eval("\x01") + 694);
  553.                                                 }
  554.                                              }
  555.                                              else if(eval("\x01") == 265)
  556.                                              {
  557.                                                 set("\x01",eval("\x01") + 47);
  558.                                                 ┬º┬ºgoto(addr776);
  559.                                                 ┬º┬ºpush(true);
  560.                                              }
  561.                                              else
  562.                                              {
  563.                                                 if(eval("\x01") == 55)
  564.                                                 {
  565.                                                    set("\x01",eval("\x01") + 445);
  566.                                                 }
  567.                                                 else if(eval("\x01") == 607)
  568.                                                 {
  569.                                                    set("\x01",eval("\x01") - 101);
  570.                                                 }
  571.                                                 else
  572.                                                 {
  573.                                                    if(eval("\x01") == 694)
  574.                                                    {
  575.                                                       set("\x01",eval("\x01") - 224);
  576.                                                       break loop0;
  577.                                                    }
  578.                                                    if(eval("\x01") == 312)
  579.                                                    {
  580.                                                       set("\x01",eval("\x01") - 9);
  581.                                                       if(┬º┬ºpop())
  582.                                                       {
  583.                                                          set("\x01",eval("\x01") + 94);
  584.                                                       }
  585.                                                       ┬º┬ºgoto(addr776);
  586.                                                    }
  587.                                                    else if(eval("\x01") == 303)
  588.                                                    {
  589.                                                       set("\x01",eval("\x01") + 94);
  590.                                                    }
  591.                                                    else
  592.                                                    {
  593.                                                       if(eval("\x01") == 470)
  594.                                                       {
  595.                                                          set("\x01",eval("\x01") + 36);
  596.                                                       }
  597.                                                       else if(eval("\x01") == 506)
  598.                                                       {
  599.                                                          set("\x01",eval("\x01") - 496);
  600.                                                          ┬º┬ºgoto(addr776);
  601.                                                          ┬º┬ºpush(true);
  602.                                                       }
  603.                                                       else
  604.                                                       {
  605.                                                          if(eval("\x01") == 459)
  606.                                                          {
  607.                                                             set("\x01",eval("\x01") - 376);
  608.                                                             break loop0;
  609.                                                          }
  610.                                                          if(eval("\x01") == 21)
  611.                                                          {
  612.                                                             set("\x01",eval("\x01") + 920);
  613.                                                          }
  614.                                                          else if(eval("\x01") == 965)
  615.                                                          {
  616.                                                             set("\x01",eval("\x01") - 197);
  617.                                                          }
  618.                                                          else if(eval("\x01") == 397)
  619.                                                          {
  620.                                                             addr1440:
  621.                                                             ┬º┬ºpush("\x01");
  622.                                                             ┬º┬ºpush(eval("\x01") + 443);
  623.                                                             while(true)
  624.                                                             {
  625.                                                                set(┬º┬ºpop(),┬º┬ºpop());
  626.                                                                ┬º┬ºgoto(addr776);
  627.                                                             }
  628.                                                             addr1440:
  629.                                                          }
  630.                                                          else
  631.                                                          {
  632.                                                             if(eval("\x01") == 674)
  633.                                                             {
  634.                                                                set("\x01",eval("\x01") + 166);
  635.                                                             }
  636.                                                             else if(eval("\x01") == 840)
  637.                                                             {
  638.                                                                set("\x01",eval("\x01") - 211);
  639.                                                                ┬º┬ºgoto(addr776);
  640.                                                                ┬º┬ºpush(true);
  641.                                                             }
  642.                                                             else
  643.                                                             {
  644.                                                                if(eval("\x01") == 314)
  645.                                                                {
  646.                                                                   set("\x01",eval("\x01") - 200);
  647.                                                                }
  648.                                                                else if(eval("\x01") == 976)
  649.                                                                {
  650.                                                                   set("\x01",eval("\x01") - 500);
  651.                                                                }
  652.                                                                else if(eval("\x01") == 784)
  653.                                                                {
  654.                                                                   set("\x01",eval("\x01") - 425);
  655.                                                                   if(┬º┬ºpop())
  656.                                                                   {
  657.                                                                      set("\x01",eval("\x01") + 396);
  658.                                                                   }
  659.                                                                }
  660.                                                                else if(eval("\x01") == 114)
  661.                                                                {
  662.                                                                   set("\x01",eval("\x01") - 82);
  663.                                                                   ┬º┬ºgoto(addr776);
  664.                                                                   ┬º┬ºpush(true);
  665.                                                                }
  666.                                                                else
  667.                                                                {
  668.                                                                   if(eval("\x01") != 886)
  669.                                                                   {
  670.                                                                      if(eval("\x01") == 935)
  671.                                                                      {
  672.                                                                         set("\x01",eval("\x01") - 935);
  673.                                                                         break loop0;
  674.                                                                      }
  675.                                                                      break loop0;
  676.                                                                   }
  677.                                                                   set("\x01",eval("\x01") + 55);
  678.                                                                   ┬º┬ºgoto(addr776);
  679.                                                                }
  680.                                                                ┬º┬ºgoto(addr776);
  681.                                                             }
  682.                                                             ┬º┬ºgoto(addr776);
  683.                                                          }
  684.                                                          ┬º┬ºgoto(addr776);
  685.                                                       }
  686.                                                       ┬º┬ºgoto(addr776);
  687.                                                    }
  688.                                                 }
  689.                                                 ┬º┬ºgoto(addr776);
  690.                                              }
  691.                                              ┬º┬ºgoto(addr776);
  692.                                           }
  693.                                           addr298:
  694.                                           set(┬º┬ºpop(),eval("\x01") - 84);
  695.                                           break loop0;
  696.                                        }
  697.                                        set("\x01",eval("\x01") + 773);
  698.                                        if(┬º┬ºpop())
  699.                                        {
  700.                                           set("\x01",eval("\x01") + 81);
  701.                                        }
  702.                                     }
  703.                                     ┬º┬ºgoto(addr776);
  704.                                  }
  705.                               }
  706.                               set("\x01",eval("\x01") - 6);
  707.                               stop();
  708.                               delete this.onEnterFrame;
  709.                               break loop0;
  710.                            }
  711.                            set("\x01",eval("\x01") + 224);
  712.                            if(┬º┬ºpop())
  713.                            {
  714.                               set("\x01",eval("\x01") + 123);
  715.                            }
  716.                         }
  717.                      }
  718.                      ┬º┬ºgoto(addr776);
  719.                   }
  720.                   ┬º┬ºgoto(addr1087);
  721.                }
  722.             }
  723.             else
  724.             {
  725.                if(eval("\x01") == 325)
  726.                {
  727.                   set("\x01",eval("\x01") + 552);
  728.                   if(┬º┬ºpop())
  729.                   {
  730.                      set("\x01",eval("\x01") - 521);
  731.                   }
  732.                   addr1568:
  733.                   while(true)
  734.                   {
  735.                      if(eval("\x01") == 346)
  736.                      {
  737.                         set("\x01",eval("\x01") + 86);
  738.                         ┬º┬ºpush(true);
  739.                         continue;
  740.                      }
  741.                      if(eval("\x01") == 551)
  742.                      {
  743.                         set("\x01",eval("\x01") + 320);
  744.                         continue;
  745.                      }
  746.                      if(eval("\x01") == 141)
  747.                      {
  748.                         set("\x01",eval("\x01") + 47);
  749.                         ┬º┬ºpush(true);
  750.                         continue;
  751.                      }
  752.                      if(eval("\x01") == 977)
  753.                      {
  754.                         set("\x01",eval("\x01") - 80);
  755.                         continue;
  756.                      }
  757.                      if(eval("\x01") == 971)
  758.                      {
  759.                         set("\x01",eval("\x01") - 793);
  760.                         if(┬º┬ºpop())
  761.                         {
  762.                            set("\x01",eval("\x01") + 329);
  763.                         }
  764.                         continue;
  765.                      }
  766.                      if(eval("\x01") == 805)
  767.                      {
  768.                         set("\x01",eval("\x01") - 662);
  769.                         continue;
  770.                      }
  771.                      if(eval("\x01") == 209)
  772.                      {
  773.                         set("\x01",eval("\x01") + 425);
  774.                         break loop0;
  775.                      }
  776.                      if(eval("\x01") == 472)
  777.                      {
  778.                         set("\x01",eval("\x01") + 355);
  779.                         if(┬º┬ºpop())
  780.                         {
  781.                            set("\x01",eval("\x01") + 150);
  782.                         }
  783.                         continue;
  784.                      }
  785.                      if(eval("\x01") == 6)
  786.                      {
  787.                         set("\x01",eval("\x01") + 203);
  788.                         if(┬º┬ºpop())
  789.                         {
  790.                            set("\x01",eval("\x01") + 425);
  791.                         }
  792.                         continue;
  793.                      }
  794.                      if(eval("\x01") == 123)
  795.                      {
  796.                         set("\x01",eval("\x01") + 20);
  797.                         continue;
  798.                      }
  799.                      if(eval("\x01") == 634)
  800.                      {
  801.                         set("\x01",eval("\x01") - 493);
  802.                         continue;
  803.                      }
  804.                      if(eval("\x01") == 508)
  805.                      {
  806.                         set("\x01",eval("\x01") + 47);
  807.                         nextFrame();
  808.                         ┬º┬ºgoto(addr304);
  809.                      }
  810.                      else
  811.                      {
  812.                         if(eval("\x01") == 188)
  813.                         {
  814.                            set("\x01",eval("\x01") + 320);
  815.                            if(┬º┬ºpop())
  816.                            {
  817.                               set("\x01",eval("\x01") + 47);
  818.                            }
  819.                            continue;
  820.                         }
  821.                         if(eval("\x01") == 921)
  822.                         {
  823.                            set("\x01",eval("\x01") - 780);
  824.                            continue;
  825.                         }
  826.                         if(eval("\x01") == 490)
  827.                         {
  828.                            set("\x01",eval("\x01") - 411);
  829.                            break loop0;
  830.                         }
  831.                         if(eval("\x01") == 396)
  832.                         {
  833.                            set("\x01",eval("\x01") + 190);
  834.                            if(┬º┬ºpop())
  835.                            {
  836.                               set("\x01",eval("\x01") + 371);
  837.                            }
  838.                            continue;
  839.                         }
  840.                         if(eval("\x01") == 24)
  841.                         {
  842.                            set("\x01",eval("\x01") + 456);
  843.                            continue;
  844.                         }
  845.                         if(eval("\x01") == 286)
  846.                         {
  847.                            set("\x01",eval("\x01") - 280);
  848.                            ┬º┬ºpush(true);
  849.                            continue;
  850.                         }
  851.                         if(eval("\x01") == 555)
  852.                         {
  853.                            set("\x01",eval("\x01") + 316);
  854.                            continue;
  855.                         }
  856.                         if(eval("\x01") == 238)
  857.                         {
  858.                            set("\x01",eval("\x01") + 733);
  859.                            ┬º┬ºpush(true);
  860.                            continue;
  861.                         }
  862.                         if(eval("\x01") == 516)
  863.                         {
  864.                            set("\x01",eval("\x01") - 44);
  865.                            ┬º┬ºpush(true);
  866.                            continue;
  867.                         }
  868.                         if(eval("\x01") != 102)
  869.                         {
  870.                            if(eval("\x01") != 871)
  871.                            {
  872.                               break;
  873.                            }
  874.                            set("\x01",eval("\x01") - 546);
  875.                            ┬º┬ºpush(true);
  876.                            continue;
  877.                         }
  878.                         set("\x01",eval("\x01") + 703);
  879.                         ┬º┬ºgoto(addr1440);
  880.                      }
  881.                   }
  882.                   continue;
  883.                   addr1568:
  884.                }
  885.                else
  886.                {
  887.                   if(eval("\x01") == 432)
  888.                   {
  889.                      set("\x01",eval("\x01") - 330);
  890.                      if(┬º┬ºpop())
  891.                      {
  892.                         set("\x01",eval("\x01") + 703);
  893.                      }
  894.                   }
  895.                   else if(eval("\x01") == 106)
  896.                   {
  897.                      set("\x01",eval("\x01") + 318);
  898.                   }
  899.                   else
  900.                   {
  901.                      if(eval("\x01") == 877)
  902.                      {
  903.                         set("\x01",eval("\x01") - 521);
  904.                         break loop0;
  905.                      }
  906.                      if(eval("\x01") == 143)
  907.                      {
  908.                         set("\x01",eval("\x01") + 548);
  909.                         ┬º┬ºgoto(addr1568);
  910.                         ┬º┬ºpush(true);
  911.                      }
  912.                      else
  913.                      {
  914.                         if(eval("\x01") == 480)
  915.                         {
  916.                            set("\x01",eval("\x01") - 84);
  917.                            ┬º┬ºgoto(addr1568);
  918.                            ┬º┬ºpush(true);
  919.                         }
  920.                         else
  921.                         {
  922.                            if(eval("\x01") == 356)
  923.                            {
  924.                               set("\x01",eval("\x01") + 124);
  925.                            }
  926.                            else
  927.                            {
  928.                               if(eval("\x01") == 586)
  929.                               {
  930.                                  set("\x01",eval("\x01") + 371);
  931.                                  ┬º┬ºpush(┬º┬ºpop().substr(┬º┬ºpop(),┬º┬ºpop()));
  932.                                  break loop0;
  933.                               }
  934.                               if(eval("\x01") == 691)
  935.                               {
  936.                                  set("\x01",eval("\x01") - 201);
  937.                                  if(┬º┬ºpop())
  938.                                  {
  939.                                     set("\x01",eval("\x01") - 411);
  940.                                  }
  941.                               }
  942.                               else if(eval("\x01") == 507)
  943.                               {
  944.                                  set("\x01",eval("\x01") - 221);
  945.                               }
  946.                               else
  947.                               {
  948.                                  if(eval("\x01") == 178)
  949.                                  {
  950.                                     set("\x01",eval("\x01") + 329);
  951.                                     set(┬º┬ºpop(),eval(┬º┬ºpop()) - 415);
  952.                                     break loop0;
  953.                                  }
  954.                                  if(eval("\x01") == 718)
  955.                                  {
  956.                                     set("\x01",eval("\x01") - 480);
  957.                                  }
  958.                                  else if(eval("\x01") == 424)
  959.                                  {
  960.                                     set("\x01",eval("\x01") + 351);
  961.                                     ┬º┬ºgoto(addr1568);
  962.                                     ┬º┬ºpush(true);
  963.                                  }
  964.                                  else
  965.                                  {
  966.                                     if(eval("\x01") == 79)
  967.                                     {
  968.                                        set("\x01",eval("\x01") + 159);
  969.                                     }
  970.                                     else if(eval("\x01") == 775)
  971.                                     {
  972.                                        set("\x01",eval("\x01") + 181);
  973.                                        if(┬º┬ºpop())
  974.                                        {
  975.                                           set("\x01",eval("\x01") - 551);
  976.                                        }
  977.                                     }
  978.                                     else if(eval("\x01") == 405)
  979.                                     {
  980.                                        set("\x01",eval("\x01") + 111);
  981.                                     }
  982.                                     else if(eval("\x01") == 650)
  983.                                     {
  984.                                        set("\x01",eval("\x01") - 134);
  985.                                     }
  986.                                     else
  987.                                     {
  988.                                        if(eval("\x01") == 827)
  989.                                        {
  990.                                           set("\x01",eval("\x01") + 150);
  991.                                           ┬º┬ºpush(┬º┬ºpop() instanceof typeof ┬º┬ºpop());
  992.                                           break loop0;
  993.                                        }
  994.                                        if(eval("\x01") != 329)
  995.                                        {
  996.                                           if(eval("\x01") == 897)
  997.                                           {
  998.                                              set("\x01",eval("\x01") - 812);
  999.                                              stop();
  1000.                                              delete this.onEnterFrame;
  1001.                                              break loop0;
  1002.                                           }
  1003.                                           if(eval("\x01") == 85)
  1004.                                           {
  1005.                                              set("\x01",eval("\x01") - 85);
  1006.                                              break loop0;
  1007.                                           }
  1008.                                           break loop0;
  1009.                                        }
  1010.                                        set("\x01",eval("\x01") + 568);
  1011.                                     }
  1012.                                     ┬º┬ºgoto(addr1568);
  1013.                                  }
  1014.                               }
  1015.                            }
  1016.                            ┬º┬ºgoto(addr1568);
  1017.                         }
  1018.                         ┬º┬ºgoto(addr1568);
  1019.                      }
  1020.                   }
  1021.                   ┬º┬ºgoto(addr1568);
  1022.                }
  1023.                ┬º┬ºgoto(addr1568);
  1024.             }
  1025.             ┬º┬ºgoto(addr1440);
  1026.          }
  1027.          ┬º┬ºgoto(addr1568);
  1028.       }
  1029.    }
  1030.    else
  1031.    {
  1032.       if(eval("\x01") == 298)
  1033.       {
  1034.          set("\x01",eval("\x01") + 352);
  1035.          if(┬º┬ºpop())
  1036.          {
  1037.             set("\x01",eval("\x01") + 153);
  1038.          }
  1039.          continue;
  1040.       }
  1041.       if(eval("\x01") == 177)
  1042.       {
  1043.          set("\x01",eval("\x01") + 8);
  1044.          break;
  1045.       }
  1046.       if(eval("\x01") == 794)
  1047.       {
  1048.          set("\x01",eval("\x01") + 115);
  1049.          continue;
  1050.       }
  1051.       if(eval("\x01") == 803)
  1052.       {
  1053.          set("\x01",eval("\x01") - 760);
  1054.          continue;
  1055.       }
  1056.       if(eval("\x01") == 660)
  1057.       {
  1058.          set("\x01",eval("\x01") - 483);
  1059.          if(┬º┬ºpop())
  1060.          {
  1061.             set("\x01",eval("\x01") + 8);
  1062.          }
  1063.          continue;
  1064.       }
  1065.       if(eval("\x01") == 989)
  1066.       {
  1067.          set("\x01",eval("\x01") - 80);
  1068.          continue;
  1069.       }
  1070.       if(eval("\x01") == 135)
  1071.       {
  1072.          set("\x01",eval("\x01") + 723);
  1073.          stop();
  1074.          break;
  1075.       }
  1076.       if(eval("\x01") == 251)
  1077.       {
  1078.          set("\x01",eval("\x01") - 116);
  1079.          continue;
  1080.       }
  1081.       if(eval("\x01") == 43)
  1082.       {
  1083.          set("\x01",eval("\x01") + 546);
  1084.          ┬º┬ºpush(true);
  1085.          continue;
  1086.       }
  1087.       if(eval("\x01") != 308)
  1088.       {
  1089.          if(eval("\x01") == 589)
  1090.          {
  1091.             set("\x01",eval("\x01") - 281);
  1092.             if(┬º┬ºpop())
  1093.             {
  1094.                set("\x01",eval("\x01") + 681);
  1095.             }
  1096.          }
  1097.          else if(eval("\x01") == 282)
  1098.          {
  1099.             set("\x01",eval("\x01") - 147);
  1100.          }
  1101.          else if(eval("\x01") == 774)
  1102.          {
  1103.             set("\x01",eval("\x01") - 731);
  1104.          }
  1105.          else if(eval("\x01") == 728)
  1106.          {
  1107.             set("\x01",eval("\x01") - 332);
  1108.             ┬º┬ºpush(true);
  1109.          }
  1110.          else
  1111.          {
  1112.             if(eval("\x01") == 650)
  1113.             {
  1114.                set("\x01",eval("\x01") + 153);
  1115.                break;
  1116.             }
  1117.             if(eval("\x01") == 858)
  1118.             {
  1119.                set("\x01",eval("\x01") - 858);
  1120.                break;
  1121.             }
  1122.             if(eval("\x01") != 185)
  1123.             {
  1124.                break;
  1125.             }
  1126.             set("\x01",eval("\x01") + 543);
  1127.          }
  1128.          continue;
  1129.       }
  1130.       set("\x01",eval("\x01") + 681);
  1131.    }
  1132.    ┬º┬ºgoto(addr1089);
  1133. }
  1134.